{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# <center>第8章 数据处理与分析基础</center>\n",
    "\n",
    "<br>\n",
    "\n",
    "- [8.1 文件读写](#8.1-文件读写)\n",
    "  - [8.1.1 文件的打开和关闭](#8.1.1-文件的打开和关闭)\n",
    "  - [8.1.2 路径管理](#8.1.2-路径管理)\n",
    "  - [8.1.3 文本文件读写](#8.1.3-文本文件读写)\n",
    "- [8.2 上下文管理](#8.2-上下文管理)\n",
    "  - [8.2.1 `with`语句块](#8.2.1-with语句块)\n",
    "  - [8.2.2 上下文管理协议*](#8.2.2-上下文管理协议*)\n",
    "- [8.3 数据库编程](#8.3-数据库编程)\n",
    "  - [8.3.1 数据库应用编程接口](#8.3.1-数据库应用编程接口)\n",
    "  - [8.3.2 嵌入式数据库编程](#8.3.2-嵌入式数据库编程)\n",
    "- [8.4 正则表达式*](#8.4-正则表达式*)\n",
    "  - [8.4.1 正则表达式匹配规则](#8.4.1-正则表达式匹配规则)\n",
    "  - [8.4.2 正则表达式的应用](#8.4.2-正则表达式的应用)\n",
    "  - [8.4.3 正则表达式的编译](#8.4.3-正则表达式的编译)\n",
    "- [8.5 数据分析中的数据结构 *](#8.5-数据分析中的数据结构-*)\n",
    "  - [8.5.1 NumPy](#8.5.1-NumPy)\n",
    "  - [8.5.2 SciPy](#8.5.2-SciPy)\n",
    "- [8.6 数据可视化*](#8.6-数据可视化*)\n",
    "  - [8.6.1 简单绘图](#8.6.1-简单绘图)\n",
    "  - [8.6.2 图像的配置与修饰](#8.6.2-图像的配置与修饰)\n",
    "  - [8.6.3 多子图图像的绘制](#8.6.3-多子图图像的绘制)\n",
    "  - [8.6.4 三维图像的绘制](#8.6.4-三维图像的绘制<br>)\n",
    "- [8.7 Pandas基础*](#8.7-Pandas基础*)\n",
    "  - [8.7.1 数据结构](#8.7.1-数据结构)\n",
    "  - [8.7.2 数据访问](#8.7.2-数据访问)\n",
    "- [8.8 Scikit-learn基础*](#8.8-Scikit-learn基础*)\n",
    "  - [8.8.1 Scikit-learn简介](#8.8.1-Scikit-learn简介)\n",
    "  - [8.8.2 分类问题](#8.8.2-分类问题)\n",
    "  - [8.8.3 聚类问题](#8.8.3-聚类问题)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 8.1 文件读写\n",
    "\n",
    "### 8.1.1 文件的打开和关闭\n",
    "\n",
    "- 为什么要打开和关闭文件？\n",
    "  - 打开文件是指将访问文件所需要的属性 信息从外存读取至内存之中，每次文件访问都会利用这些信息来对文件进行读、写操作， 从而避免频繁的文件检索，提升文件访问的效率\n",
    "  - 文件访问任务完成之后，需要关闭文 件以释放这些文件信息，同时将文件属性信息的变化写入磁盘文件之中\n",
    "\n",
    "- `open`函数\n",
    "  - 开文件并返回一个文件对象"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- `open`函数的参数\n",
    "  - `file`： 取值为一个类路径对象(path-like object)\n",
    "  - `mode`:模式字符串，用于指定文件的打开模式"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 文件的打开模式\n",
    "\n",
    "|模式字符 |含义|\n",
    "|:--|:--|\n",
    "|'r' |读取模式(默认)|\n",
    "| 'w' |写入模式，如果文件存在则将其覆盖|\n",
    "| 'a' |写入模式，如果文件存在则将写入内容追加至尾部 'x' 排它性创建模式，如果文件已存在则打开失败 'b' 二进制模式|\n",
    "| 't' |文本模式(默认)|\n",
    "| '+' |更新模式(可读可写)|\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 组合打开模式\n",
    "  - 'rb'：以二进制文件读取模式打开\n",
    "  - 'wb'：以二进制文件写 入模式打开\n",
    "  - 'a+'：以文本文件读取和追加模式打开\n",
    "  - 'ab+'：以二进制文件 读取和追加模式打开\n",
    "  - 'w+'：以文本文件读写模式打开"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 文件访问的过程\n",
    "\n",
    "```python\n",
    ">>> f = open('/path/to/file', 'rt') ...\n",
    "# 文件读写操作\n",
    "...\n",
    ">>> f.close()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 8.1.2 路径管理\n",
    "\n",
    "- `os`模块和`os.path`子模块\n",
    "\n",
    "|函数 | 功能|\n",
    "|:--|:--|\n",
    "|`os.listdir(path)`|返回 `path` 文件夹中的文件名构成的列表|\n",
    "|`os.path.exists(path)`|路径 `path` 是否存在|\n",
    "|`os.path.isabs(path)`|`path` 是否为绝对路径|\n",
    "|`os.path.isdir(path)`|`path` 是否为目录|\n",
    "|`os.path.isfile(path)`|`path` 是否为文件|\n",
    "|`os.path.abspath(path)`|获取 `path` 的绝对路径|\n",
    "|`os.path.basename(path)`|获取 `path` 的最后一项(文件名或最底层文件夹) |\n",
    "|`os.path.dirname(path)`|获取 `path` 中 `basename` 的所在路径|\n",
    "|`os.path.split(path)`|将 `path` 切分为 `dirname` 和 `basename` 两部分|\n",
    "|`os.path.getsize(path)`|获取文件的大小(字节) |\n",
    "|`os.path.getatime(path)`|获取文件或路径的最后访问时间(秒) |\n",
    "|`os.path.getmtime(path)`|获取文件或路径的最后修改时间(秒) |\n",
    "|`os.path.join(path1, path2, ...)`|将多个路径片段拼接为一个合法的路径|\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 首先需要在计算机 桌面上创建文件'file.txt'，然后打开命令行终端并进入用户主目录，进入Python环境并执行如下命令\n",
    "\n",
    "```python\n",
    ">>> from os.path import *\n",
    ">>> path = join('./Desktop/', 'file.txt')\n",
    ">>> abs_path = abspath(path)\n",
    ">>> abs_path\n",
    "'/Users/username/Desktop/file.txt'\n",
    ">>> isabs(abs_path)\n",
    "True\n",
    ">>> isfile(abs_path)\n",
    "True\n",
    ">>> isdir(abs_path)\n",
    "False\n",
    ">>> basename(abs_path)\n",
    "'file.txt'\n",
    ">>> dirname(abs_path)\n",
    "'/Users/username/Desktop'\n",
    ">>> split(abs_path)\n",
    "('/Users/username/Desktop', 'file.txt')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- `pathlib`模块\n",
    "  - 对路径管理功能进行了封装，该模块的关键组成部分是三个类Path、 WindowsPath和PosixPath，分别用于处理 Windows 风格 的路径及 Posix(Linux、macOS 等)风格的路径\n",
    "\n",
    "```python\n",
    ">>> from pathlib import Path\n",
    ">>> path = Path('./Desktop')           # 创建Path对象\n",
    ">>> path = path / 'file.txt'           # 路径拼接\n",
    ">>> path\n",
    "PosixPath('Desktop/file.txt')\n",
    ">>> path = path.absolute()             # 获取绝对路径\n",
    ">>> path\n",
    "PosixPath('/Users/username/Desktop/file.txt')\n",
    ">>> path.exists()                      # 判断文件或文件夹是否存在\n",
    "True\n",
    ">>> path.is_file()                     # 判断指定路径是否是文件\n",
    "True\n",
    ">>> path.is_dir()                      # 判断指定路径是否是文件夹\n",
    "False\n",
    ">>> path.name                          # 获取文件名\n",
    "'file.txt'\n",
    ">>> path.parent\n",
    "PosixPath('/Users/username/Desktop')\n",
    ">>> path_iter = path.parent.iterdir()  # 获取父目录的迭代器\n",
    ">>> list(path_iter)                    # 获取父目录中的文件列表\n",
    "[PosixPath('/Users/username/Desktop/file.txt'), ... ]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 8.1.3 文本文件读写\n",
    "\n",
    "#### 常用文本文件读写方法\n",
    "  - `read()`:读入文本文件全部内容作为字符串返回;\n",
    "  - `readline()`:读入文本文件中的一行并将文件指针的位置后移一行;\n",
    "  - `readlines()`:读入文本文件全部内容，返回一个字符串列表，列表中的每个元素是文本文件的一行内容;\n",
    "  -  `write(text_str)`:将`text_str`表示的字符串写入文本文件;\n",
    "  - `writelines(str_iter)`:将可迭代对象`str_iter`写入文本文件，`str_iter`中的每个字符串作为文件的一行。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```python\n",
    ">>> f = open('./file.txt', 'w')               # 以写入模式打开文件\n",
    ">>> f.write('line1\\nline2\\nline3\\n')          # 写入第1到3行内容\n",
    "18\n",
    ">>> f.writelines(['line4\\n', 'line5\\n'])      # 写入第4、5行内容\n",
    ">>> f.close()                                 # 关闭文件\n",
    ">>> f = open('./file.txt')                    # 以读取模式打开文件\n",
    ">>> f.read()                                  # 读取文件全部内容\n",
    "'line1\\nline2\\nline3\\nline4\\nline5\\n'\n",
    ">>> f.seek(0)                                 # 移动文件指针至起始位置\n",
    "0\n",
    ">>> f.readlines()                             # 按行读取文件全部内容\n",
    "['line1\\n', 'line2\\n', 'line3\\n', 'line4\\n', 'line5\\n']\n",
    ">>> f.close()\n",
    ">>> f = open('./file.txt', 'a')               # 以追回模式打开文件\n",
    ">>> f.write('line6\\nline7\\n')                 # 追加写入第6、7行内容\n",
    "12\n",
    ">>> f.close()\n",
    ">>> f = open('./file.txt')\n",
    ">>> f.read()\n",
    "'line1\\nline2\\nline3\\nline4\\nline5\\nline6\\nline7\\n'\n",
    ">>> f.close()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 大文件的读取\n",
    "\n",
    "- `read`方法和`readlines`方法会读入整个文件，在读取较大的文本文件时非常耗时，更严重的是可能会由于内存不足而使得程序无法运行\n",
    "- 解决方法1：使用`readline`方法\n",
    "\n",
    "```python\n",
    "f = open('/path/to/file.txt')\n",
    "while True:\n",
    "    line = f.readline()\n",
    "    if not line:\n",
    "        break\n",
    "    # 对文本行line进行处理\n",
    "f.close()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 解决方法2：直接对文件对象进行迭代\n",
    "\n",
    "```python\n",
    "f = open('/path/to/file.txt')\n",
    "for line in f:\n",
    "    pass\n",
    "    # 对文本行line进行处理\n",
    "f.close()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 二进制文件读写*\n",
    "\n",
    "- 使用`open`函数以`'rb'`和`'wb'`模式打开文件，即可对二进制文件进行读写操作\n",
    "\n",
    "```python\n",
    "f = open('/path/to/binfile.bin', 'wb')  # 以二进制写入模式打开文件\n",
    "f.write('二进制字节串'.encode('utf-8')) # 字符串编码为字节串，并写入文件\n",
    "f.close()\n",
    "\n",
    "f = open('/path/to/binfile.bin', 'rb')  # 以二进制读取模式打开文件\n",
    "content = f.read()\n",
    "f.close()\n",
    "print(\"解码前：\", content)\n",
    "content = content.decode('utf-8')       # 对字节串进行解码\n",
    "print(\"解码后：\", content)\n",
    "```\n",
    "输出：\n",
    "```python\n",
    "解码前： b'\\xe4\\xba\\x8c\\xe8\\xbf\\x9b\\xe5\\x88\\xb6\\xe5\\xad\\x97\\xe8\\x8a\\x82\\xe4\\xb8\\xb2'\n",
    "解码后： 二进制字节串\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 8.2 上下文管理\n",
    "\n",
    "- 上下文\n",
    "  - 指程序运行的环境，某些操作只有在相应的环境或上下文之中时才能正确地运行\n",
    "  - 文件的读写操作必须在文件已经被打开的上下文之中\n",
    "  - 数据库的访问必 须在成功建立数据库连接的上下文之中\n",
    "- 上下文管理\n",
    "  - 上下文环境构建\n",
    "  - 操作过程中的异常处理\n",
    "  - 上下文环境的清理\n",
    "  - ... ...\n",
    "  - Python 将 构建和清理上下文环境的过程独离出来，称为上下文管理\n",
    "- 上下文管理器\n",
    "  - 具有上下文管理功能的对象，称为上下文管理器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 8.2.1 `with`语句块\n",
    "\n",
    "- `with`语句块会调用上下文管理器的相关方法来构建上下文环境\n",
    "  - 文件对象就是一个上下文管理器\n",
    "  - 利用`with`可以更加方便、安全地访问文件\n",
    "  \n",
    "```python\n",
    "# 写入文件\n",
    "with open('/path/to/filename.txt', 'w') as f:\n",
    "    f.write('file contents')\n",
    "\n",
    "# 读取文件\n",
    "with open('/path/to/filename.txt', 'r') as f:\n",
    "    print(f.read())\n",
    "```\n",
    "\n",
    "- 利用`with`读取大文件\n",
    "\n",
    "```python\n",
    "with open('/path/to/file.txt') as f: \n",
    "    while True:\n",
    "        line = f.readline()\n",
    "        if not line:\n",
    "            break\n",
    "        # 对文本行line进行处理\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 8.2.2 上下文管理协议*\n",
    "\n",
    "- 上下文管理功能由上下文管理协议约定，上下文管理器就是实现了上下文管理协议的类的实例\n",
    "- 上下文管理协议\n",
    "  - `__enter__(self)`:进入`with`语句块时调用该方法，返回上下文管理器自身或者相关的对象，若有`as`子句则返回对象会被赋值给`as`子句中的变量\n",
    "  - `__exit__(self, exc_type, exc_val, exc_tb)`:离开`with`语句块时调用该方法\n",
    "    - 如果`with`语句块中的代码在执行过程中抛出异常，则异常类型、异常值，以及异常追踪信息分别被传递至三个参数`exc_type`、`exc_val`和`exc_tb`\n",
    "    - 如果没有异常发生， 则传入的三个值都是`None`\n",
    "    - 该方法的返回值为一个布尔值，`True`表示不再向上抛出 捕获的异常，`False`表示继续抛出异常。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 自定义上下文管理器\n",
    "\n",
    "- 不再抛出with语句块中的异常"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class File:\n",
    "    def __init__(self, path, mode):\n",
    "        self.path = path\n",
    "        self.mode = mode\n",
    "\n",
    "    def __enter__(self):\n",
    "        print(\"进入上下文环境...\")\n",
    "        self.file = open(self.path, self.mode)\n",
    "        return self.file\n",
    "\n",
    "    def __exit__(self, exc_type, exc_val, exc_tb):\n",
    "        print(\"离开上下文环境...\")\n",
    "        self.file.close()\n",
    "        print('异常类型：', exc_type)\n",
    "        print('异常值：', exc_val)\n",
    "        print('异常跟踪：', exc_tb)\n",
    "        return True               # 不再抛出with语句块中的异常"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "进入上下文环境...\n",
      "离开上下文环境...\n",
      "异常类型： <class 'Exception'>\n",
      "异常值： 程序运行发生异常\n",
      "异常跟踪： <traceback object at 0x7f7f04191d40>\n"
     ]
    }
   ],
   "source": [
    "with File('test_file', 'w') as f:\n",
    "    f.write('file contents')\n",
    "    raise Exception('程序运行发生异常')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 抛出with语句块中的异常"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class File:\n",
    "    def __init__(self, path, mode):\n",
    "        self.path = path\n",
    "        self.mode = mode\n",
    "\n",
    "    def __enter__(self):\n",
    "        print(\"进入上下文环境...\")\n",
    "        self.file = open(self.path, self.mode)\n",
    "        return self.file\n",
    "\n",
    "    def __exit__(self, exc_type, exc_val, exc_tb):\n",
    "        print(\"离开上下文环境...\")\n",
    "        self.file.close()\n",
    "        print('异常类型：', exc_type)\n",
    "        print('异常值：', exc_val)\n",
    "        print('异常跟踪：', exc_tb)\n",
    "        return False            # 抛出with语句块中的异常"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "进入上下文环境...\n",
      "离开上下文环境...\n",
      "异常类型： <class 'Exception'>\n",
      "异常值： 程序运行发生异常\n",
      "异常跟踪： <traceback object at 0x7f7f04217800>\n"
     ]
    },
    {
     "ename": "Exception",
     "evalue": "程序运行发生异常",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mException\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-4-7a29cbfd732b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mFile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'test_file'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'w'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'file contents'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'程序运行发生异常'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mException\u001b[0m: 程序运行发生异常"
     ]
    }
   ],
   "source": [
    "with File('test_file', 'w') as f:\n",
    "    f.write('file contents')\n",
    "    raise Exception('程序运行发生异常')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 应用\n",
    "- 利用上下文管理器计算代码块的运行时间"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "class CodeRunTime:\n",
    "    def __enter__(self):\n",
    "        self.start = time.perf_counter()\n",
    "\n",
    "    def __exit__(self, exc_type, exc_val, exc_tb):\n",
    "        print(f'代码块运行时间：{time.perf_counter() - self.start}')\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "代码块运行时间：0.1913649619998523\n"
     ]
    }
   ],
   "source": [
    "with CodeRunTime():\n",
    "    lst = []\n",
    "    for i in range(1000000):\n",
    "        lst.append(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 8.3 数据库编程\n",
    "\n",
    "### 8.3.1 数据库应用编程接口\n",
    "\n",
    "- 数据库访问过程\n",
    "\n",
    "<center>\n",
    "    <img src=\"./figures/fig8-1.png\" width=\"40%\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 数据库适配器\n",
    "  - 是数据库管理系统在 Python 中的驱动应用程序，作为客户端与数据库服务器进行通信\n",
    "  - Python 官方给出了适配器 开发的统一规范，即数据库应用编程接口(DB-API)，该规范由 PEP249 定义"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 数据库应用编程接口(PEP249)\n",
    "\n",
    "<table align=\"center\">\n",
    "    <thead>\n",
    "        <td style=\"text-align:center;\">类型</td>\n",
    "        <td colspan=\"2\" style=\"text-align:center;\">名称</td>\n",
    "        <td style=\"text-align:center;\">功能</td>\n",
    "    </thead>\n",
    "    <tbody>\n",
    "        <tr>\n",
    "            <td rowspan=\"3\" style=\"text-align:left;\"> 全局属性 </td>\n",
    "            <td colspan=\"2\" style=\"text-align:left;\"> <tt>apilevel</tt></td>\n",
    "            <td style=\"text-align:left;\"> 字符串，兼容的 DB-API 版本(1.0 或 2.0) </td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td colspan=\"2\" style=\"text-align:left;\"> <tt>threadsafety</tt> </td>\n",
    "            <td style=\"text-align:left;\"> 线程安全级别(0 至 5) </td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td colspan=\"2\" style=\"text-align:left;\"> <tt>paramstyle</tt> </td>\n",
    "            <td style=\"text-align:left;\"> SQL 语句中占位符的风格(五种类型) </td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td style=\"text-align:left;\">函数</td>\n",
    "            <td colspan=\"2\" style=\"text-align:left;\"><tt>connect</tt></td>\n",
    "            <td style=\"text-align:left;\"> 建立并返回数据库连接 (<tt>Connection</tt>) 对象 </td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td rowspan=\"13\" style=\"text-align:left;\">类.方法</td>\n",
    "            <td rowspan=\"4\" style=\"text-align:left;\"><tt>Connection</tt></td>\n",
    "            <td style=\"text-align:left;\"><tt>.close</tt></td>\n",
    "            <td style=\"text-align:left;\">关闭数据库连接</td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td style=\"text-align:left;\"><tt>.commit</tt></td>\n",
    "            <td style=\"text-align:left;\">提交事务或操作<td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td style=\"text-align:left;\"><tt>.rollback</tt></td>\n",
    "            <td style=\"text-align:left;\">回滚事务<td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td style=\"text-align:left;\"><tt>.cursor</tt></td>\n",
    "            <td style=\"text-align:left;\">获取游标 (<tt>Cursor</tt>) 对象<td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td rowspan=\"9\" style=\"text-align:left; border-top:#cccccc solid 1px;\"><tt>Cursor</tt></td>\n",
    "            <td style=\"text-align:left; border-top:#cccccc solid 1px;\"><tt>.description</tt></td>\n",
    "            <td style=\"text-align:left; border-top:#cccccc solid 1px;\">游标状态描述信息(属性)</td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td style=\"text-align:left;\"><tt>.rowcount</tt></td>\n",
    "            <td style=\"text-align:left;\">最近一次操作的影响行数 (属性)<td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td style=\"text-align:left;\"><tt>.callproc</tt></td>\n",
    "            <td style=\"text-align:left;\">调用数据库存储过程<td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td style=\"text-align:left;\"><tt>.close</tt></td>\n",
    "            <td style=\"text-align:left;\">关闭游标<td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td style=\"text-align:left;\"><tt>.execute</tt></td>\n",
    "            <td style=\"text-align:left;\">执行 SQL 语句<td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td style=\"text-align:left;\"><tt>.executemany</tt></td>\n",
    "            <td style=\"text-align:left;\">利用一组参数多次执行同一 SQL 语句<td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td style=\"text-align:left;\"><tt>.fetchone</tt></td>\n",
    "            <td style=\"text-align:left;\">获取查询结果中的下一条记录<td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td style=\"text-align:left;\"><tt>.fetchmany</tt></td>\n",
    "            <td style=\"text-align:left;\">获取查询结果中指定数量的记录<td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td style=\"text-align:left;\"><tt>.fetchall</tt></td>\n",
    "            <td style=\"text-align:left;\">获取查询结果中的剩余的全部记录<td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td rowspan=\"7\" style=\"text-align:left;\">异常类</td>\n",
    "            <td colspan=\"2\" style=\"text-align:left;\"><tt>InterfaceError</tt></td>\n",
    "            <td style=\"text-align:left;\">数据库接口错误</td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td colspan=\"2\" style=\"text-align:left;\"><tt>DataError</tt></td>\n",
    "            <td style=\"text-align:left;\">数据处理错误</td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td colspan=\"2\" style=\"text-align:left;\"><tt>OperationalError</tt></td>\n",
    "            <td style=\"text-align:left;\">数据库操作执行错误</td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td colspan=\"2\" style=\"text-align:left;\"><tt>IntegrityError</tt></td>\n",
    "            <td style=\"text-align:left;\">数据库完整性错误</td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td colspan=\"2\" style=\"text-align:left;\"><tt>InternalError</tt></td>\n",
    "            <td style=\"text-align:left;\">数据库内部错误</td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td colspan=\"2\" style=\"text-align:left;\"><tt>ProgrammingError</tt></td>\n",
    "            <td style=\"text-align:left;\">SQL错误</td>\n",
    "        </tr>\n",
    "        <tr>\n",
    "            <td colspan=\"2\" style=\"text-align:left;\"><tt>NotSupportedError</tt></td>\n",
    "            <td style=\"text-align:left;\">操作不被支持错误</td>\n",
    "        </tr>\n",
    "    </tbody>\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- DB-API 的 paramstyle 属性\n",
    "\n",
    "|取值| SQL 参数风格示例|\n",
    "|:--|:--|\n",
    "|`'qmark'`|`...WHERE name=?`|\n",
    "|`'numeric'`|`...WHERE name=:1`|\n",
    "|`'named'`|`...WHERE name=:name`|\n",
    "|`'format'`|`...WHERE name=%s`|\n",
    "|`'pyformat'`|`...WHERE name=%(name)s`|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- PEP249 是一种官方建议的数据库适配器工具包开发规范，不具有强制性，实际的数据库适配器对 PEP249 规范的遵循程度不一致"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 8.3.2 嵌入式数据库编程\n",
    "\n",
    "- 嵌入式数据库编程的一般步骤:\n",
    "  - 建立数据库连接\n",
    "  - 获取游标\n",
    "  - 执行 SQL 语句\n",
    "  - 提交事务或操作\n",
    "  - 关闭游标和数据库连接\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 创建sqlite数据库和表"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sqlite3\n",
    "conn = sqlite3.connect('test.db')          # 建立数据库连接\n",
    "cur = conn.cursor()                        # 获取游标\n",
    "sql = 'create table users(id int primary key, name varchar, email varchar)'\n",
    "cur.execute(sql)                           # 执行SQL语句\n",
    "cur.close()                                # 关闭游标\n",
    "conn.close()                               # 关闭数据库连接"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 数据的添加、修改和删除操作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sqlite3\n",
    "conn = sqlite3.connect(\"test.db\")  # 建立数据库连接\n",
    "cur = conn.cursor()                # 获取游标\n",
    "\n",
    "sql = \"insert into users values(1, '张三', 'zhangsan@test.com')\"\n",
    "cur.execute(sql)                   # 添加一条数据\n",
    "\n",
    "sql = \"insert into users values(?,?,?)\"\n",
    "data = [(2, '李四', 'lisi@test.com'),\n",
    "        (3, '王五', 'wangwu@test.com'),\n",
    "        (4, '赵六', 'zhaoliu@test.com')]\n",
    "cur.executemany(sql, data)         # 添加多条数据\n",
    "\n",
    "sql = \"update users set email='lisi_new@test.com' where id=2\"\n",
    "cur.execute(sql)                   # 修改数据\n",
    "\n",
    "sql = \"delete from users where id=3\"\n",
    "cur.execute(sql)                   # 删除数据\n",
    "conn.commit()                      # 提交操作\n",
    "cur.close()\n",
    "conn.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 数据查询操作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, '张三', 'zhangsan@test.com')\n",
      "(2, '李四', 'lisi_new@test.com')\n",
      "(4, '赵六', 'zhaoliu@test.com')\n"
     ]
    }
   ],
   "source": [
    "import sqlite3\n",
    "\n",
    "sql = 'select * from users'\n",
    "with sqlite3.connect(\"test.db\") as conn:\n",
    "    cur = conn.cursor()\n",
    "    cur.execute(sql)                # 执行查询语句\n",
    "    records = cur.fetchall()        # 获取查询结果\n",
    "for row in records:\n",
    "    print(row)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 8.4 正则表达式*\n",
    "\n",
    "- 尽管Python的字符串处理方法非常强大，但还是难以应对一些复杂的字符串处理任务\n",
    "  - 判断一个邮箱地址、手机号码是否合法\n",
    "  - 提取出HTML文档中所有需要的数据\n",
    "- 设计思想\n",
    "  - 利用一种描述性语言定义规则，然后利用该规则来匹配字符串或字符串文档，找出所有满足规则的部分\n",
    "- 应用场景\n",
    "  - 匹配性检查，即判断某个字符串是否匹配特定的模式\n",
    "  - 文本提取，即提取字符串文本中与规则相匹配的内容\n",
    "  - 切分字符串，即将字符串文本在与规则相匹配的位置进行切分\n",
    "  - 字符串替换，即将字符串文本中与规则相匹配的内容进行替换\n",
    "- Python的`re`模块提供了正则表达式功能"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 8.4.1 正则表达式匹配规则\n",
    "\n",
    "- 字符匹配\n",
    "- 边界匹配\n",
    "- 重复限制\n",
    "- 分组\n",
    "- 后向引用\n",
    "- 前置条件和后置条件"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "-  字符匹配\n",
    "\n",
    "| 符号 | 功能 | 规则示例 | 匹配示例 |\n",
    "| :---- | :---- | :-------- | :-------- |\n",
    "| `.` | 匹配`\\n`之外任一字符 | `r'.'` | `'A'` |\n",
    "| `\\d` | 匹配一个数字 | `r'\\d'` | `'9'` |\n",
    "| `\\D` | 匹配一个非数字 | `r'\\D'` | `'A'` |\n",
    "| `\\w` | 匹配一个字母、数字或下划线 | `r'\\w'` | `'_'` |\n",
    "| `\\W` | 匹配一个`\\w`之外的字符 | `r'\\W'` | `'\\t'` |\n",
    "| `\\s` | 匹配任何空白字符 | `r'\\s'` | `'\\n'` |\n",
    "| `\\S` | 匹配任何非空白字符 | `r'\\S'` | `'A'` |\n",
    "|`x\\|y`|匹配`x`或`y`|`r'a\\|b\\|c'`|`'a'`|\n",
    "|`[xyz]`|匹配`xyz`中的任一字符|`r'[abc]'`|`'a'`|\n",
    "|`[x-z]`|匹配`x`到`z`之间的任一字符|`r[X-Z]`|`'Y'`|\n",
    "|`[^xyz]`|匹配`xyz`之外的任一字符|`r[^1-9]`|`'A'`|\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 边界匹配\n",
    "\n",
    "| 符号 | 功能 | 规则示例 | 匹配示例 | 不匹配示例|\n",
    "| :---- | :---- | :-------- | :-------- | :---|\n",
    "| `^` | 行头 | `r'^Py'` | `'the\\nPython'` | `'the Python'` |\n",
    "| `$` | 行尾 | `r'the$'` | `'the\\nPython'` | `'the Python'` |\n",
    "| `\\b` | 单词边界 | `r'\\bPy'` | `'the Python'` | `'the-Python'` |\n",
    "| `\\B` | 不是单词边界 | `r'\\BPy'` | `'the-Python'` | `'the Python'` |\n",
    "| `\\A` | 字符串头 | `r'\\A'Py` | `'Python coding'` | `'the\\nPython'` |\n",
    "| `\\Z` | 字符串尾 | `r'on\\Z'` | `'the Python'` | `'Python coding'` |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 重复限制\n",
    "\n",
    "| 符号 | 功能 | 规则示例 | 匹配示例 | 不匹配示例|\n",
    "| :---- | :---- | :-------- | :-------- | :---|\n",
    "|`*`| 重复零次或多次| `r'\\d*'` | `'123abc'` |  |\n",
    "|`+`| 重复一次或多次| `r'\\d+'` | `'123abc'` | `'abc'` |\n",
    "|`?`| 重复零次或一次| `r'\\d?'` | `'1abc'` |  |\n",
    "|`{n}`| 重复n次| `r'\\d{3}'` | `'123abc'` | `'12abc'` |\n",
    "|`{n,m}`| 重复最少n次最多m次| `r'\\d{2,3}'` | `'123abc'` | `'1abc'` |\n",
    "|`{n,}`| 最少重复n次| `r'\\d{2,}'` | `'12abc'` | `'1abc'` |\n",
    "|`{,m}`| 最多重复m次| `r'\\d{,2}'` | `'12abc'` | `'123abc'` |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 贪婪匹配与懒惰匹配\n",
    "  - 使用重复限制后，正则表达式规则在匹配文本时会出现匹配内容长度不能确定的问题\n",
    "  \n",
    "   例如，规则`r'\\w{3,5}'`在匹配字符串`'abcde'`时，它的三个子串`'abc'`、`'abcd'`和`'abcde'`都附合规则，那么它匹配到的究竟是哪个子串呢？\n",
    "   \n",
    "   Python正则表达式默认情况下匹配到的是最长的子串，这种方式称为__贪婪匹配__。\n",
    "  - 重复限制符号后添加`?`即表示待重复部分为__懒惰匹配__\n",
    "  \n",
    "\n",
    "| 符号     | 功能                               |\n",
    "| :-------- | :---------------------------------- |\n",
    "| `*?`     | 重复零次或多次，但次数尽可能少     |\n",
    "| `+?`     | 重复一次或多次，但次数尽可能少     |\n",
    "| `??`     | 重复零次或一次，但次数尽可能少     |\n",
    "| `{n}?`   | 重复n次，但次数尽可能少            |\n",
    "| `{n,m}?` | 重复最少n次最多m次，但次数尽可能少 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 分组与后向引用\n",
    "  - 正则表达式中使用`()`将多个符号作为一个分组\n",
    "    例如，规则`r'(\\d{1,3}\\.){3}\\d{1,3}'`用于匹配IP地址\n",
    "  - 分组匹配到的文本内容编号并保存在缓存之中\n",
    "    - 编号方式为：`\\1`表示匹配到的第1个内容，`\\2`表示匹配到的第2个内容，... ...\n",
    "    - 缓存数据可实现文本内容的提取\n",
    "    - 缓存的数据可以被正则表达式后续部分引用，称为__后向引用__\n",
    "    - 在分组中添加`?:`表示不缓存匹配内容，例如`r(?:\\d{1,3})`\n",
    "  - 命名分组\n",
    "    - Python中命名分组的方式为`(?P<group_name>)`\n",
    "    - 后向引用中使用分组名`(?P=group_name)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 前置条件和后置条件\n",
    "\n",
    "| 规则                | 说明       |  规则示例  |  匹配示例    | 不匹配示例 |\n",
    "| :------------------- | :---------- | :---- | :---- | :------------------- |\n",
    "| `r'(?=sub_rules)'`  | 后置条件   | `r'abc(?=[de])'` | `'abcd'`或`'abce'` | `'abcf'` |\n",
    "| `r'(?!sub_rules)'`  | 后置非条件 | `r'abc(?![de])'` | `'abcf'` | `'abcd'`或`'abce'` |\n",
    "| `r'(?<=sub_rules)'` | 前置条件   | `r'(?<=[ab])cde'` | `'acde'`或`'bcde'` | `'fcde'` |\n",
    "| `r'(?<!sub_rules)'` | 前置非条件 | `r'(?<![ab])cde'` | `'fcde'` | `'acde'`或`'bcde'` |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 8.4.2 正则表达式的应用\n",
    "\n",
    "#### 匹配性检查\n",
    "\n",
    "- 实现\n",
    "  - `re.match`函数\n",
    "  - `re.search`函数\n",
    "- `Match`对象\n",
    "  - `start`\n",
    "  - `end`\n",
    "  - `span`\n",
    "  - `group`\n",
    "  - `groups`\n",
    "  - `groupdict`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<re.Match object; span=(0, 13), match='test@mail.com'>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from re import match\n",
    "rule = r'^\\w{3,}@\\w+\\.(?P<suffix>com|cn|net)$'\n",
    "result = match(rule, 'test@mail.com')\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "13\n",
      "(0, 13)\n"
     ]
    }
   ],
   "source": [
    "print(result.start())\n",
    "print(result.end())\n",
    "print(result.span())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('test@mail.com', 'com')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result.group(0, 1)   # 返回一个或多个分组（0号和1号分组）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('com',)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result.groups()      # 返回所有在规则中指定的分组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'suffix': 'com'}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result.groupdict()   # 返回命名分组构成的字典"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- `match`和`search`都只返回字符串中第一次匹配到的结果，即其中有多个满足规则的内容\n",
    "- 两者的区别在于，当字符串包含多行时，`match`只会搜索第一行，而`search`则会搜索整个字符串"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from re import search\n",
    "rule = r'\\w{3,}@\\w+\\.(com|cn|net)'\n",
    "text = 'my email is :\\n test@mail.com'   # 多行字符串\n",
    "match(rule, text) is None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<re.Match object; span=(15, 28), match='test@mail.com'>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "search(rule, text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 文本提取\n",
    "\n",
    "- 实现\n",
    "  - `re.findall`\n",
    "    - 会搜索字符串文本，并返回所有与规则相匹配的内容构成的列表\n",
    "  - `re.finditer`\n",
    "    - 返回一个生成器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('test1@mail1.com', 'com'), ('test2@mail2.net', 'net')]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from re import findall\n",
    "rule = r'(\\w{3,}@\\w+\\.(com|cn|net))'\n",
    "text = ''' I have two emials. They are test1@mail1.com\n",
    "                                   and test2@mail2.net.'''\n",
    "findall(rule, text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['test1@mail1.com', 'test2@mail2.net']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rule = r'(\\w{3,}@\\w+\\.(?:com|cn|net))'  # 不缓存不需要的分组\n",
    "findall(rule, text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 切分字符串\n",
    "\n",
    "- 实现\n",
    "  - `re.split`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c', 'd', 'e', 'f', 'g']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from re import split\n",
    "text = 'a,b;c.d e|f-g'\n",
    "rule = r'[,\\;\\.\\ |-]'\n",
    "split(rule, text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 字符串替换\n",
    "\n",
    "- 实现\n",
    "  - `re.sub`\n",
    "    - 返回替换后的字符串\n",
    "  - `re.subn`\n",
    "    - 返回由替换后的字符串和替换次数组成的元组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I have two emials. They are ***@mail1.com and ***@mail2.net.'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from re import sub\n",
    "text = 'I have two emials. They are test1@mail1.com and test2@mail2.net.'\n",
    "rule = r'(\\w{3,})(?=@\\w+\\.(com|cn|net))'\n",
    "sub(rule, '***', text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 8.4.3 正则表达式的编译\n",
    "\n",
    "- 正则表达式的使用过程\n",
    "  - 1 编译\n",
    "  - 2 匹配\n",
    "  - 每次调用都会重新编译一次\n",
    "- 提高效率的方式\n",
    "  - 编译和匹配分开\n",
    "- 实现\n",
    "  - `re.compile`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I have two emials. They are ***@mail1.com and ***@mail2.net.'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from re import compile\n",
    "text = 'I have two emials. They are test1@mail1.com and test2@mail2.net.'\n",
    "regex = compile(r'(\\w{3,})(?=@\\w+\\.(com|cn|net))')\n",
    "regex.sub('***', text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 8.5 数据分析中的数据结构 *\n",
    "\n",
    "### 8.5.1 NumPy\n",
    "\n",
    "- NumPy 是一种高效的矩阵/高维数组计算工具包，几乎所有的数据 分析和处理工具都依赖或支持 NumPy\n",
    "\n",
    "#### `ndarray`\n",
    "\n",
    "- NumPy 中最核心的数据类型\n",
    "- 创建`ndarray`常常使用 Numpy 中的`array`函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "nda = np.array([[1, 4, 2],[8, 5, 7]])\n",
    "type(nda)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4, 2],\n",
       "       [8, 5, 7]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nda"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 创建特殊结构的ndarray\n",
    "\n",
    "|函数 |功能描述|\n",
    "|:--|:--|\n",
    "|`zeros`| 创建全 0 的多维数组|\n",
    "|`ones`| 创建全 1 的多维数组|\n",
    "|`eye`| 创建对角线元素为 1 的二维数组 |\n",
    "|`random.rand`| 以随机生成的数据创建多维数组|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.zeros(shape=[3,3])   # 3行3列元素为0的多维数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(shape=[3,3])    # 3行3列元素为1的多维数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 0., 1.]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.eye(3)               # 3阶单位矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.93886107, 0.05554724, 0.07318204],\n",
       "       [0.81070672, 0.99872441, 0.61734829],\n",
       "       [0.8443944 , 0.65327837, 0.93905703]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.rand(3,3)     # 3行3列由随机数字组成的多维数组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 多维数组的操作\n",
    "\n",
    "- 元素访问与过滤"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.45003522, 0.88112387, 0.00835263, 0.20844166, 0.81008449])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "nda = np.random.rand(5)\n",
    "nda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.45003522, 0.00835263, 0.81008449])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nda[[0, 2, 4]] # 获取索引为0、2、4的三个元素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.45003522, 0.88112387, 0.81008449])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nda[nda>0.3] # 获 取 大 于0.3的 元 素"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 改变形状与维度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11, 12],\n",
       "       [21, 22],\n",
       "       [31, 32]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nda = np.array([[11, 12],[21, 22], [31, 32]])\n",
    "nda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11, 12, 21],\n",
       "       [22, 31, 32]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nda.reshape(2, 3)      # 转换为2行3列"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11, 21, 31],\n",
       "       [12, 22, 32]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nda.transpose(1, 0)    # 转置"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 元素运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.99999021, -0.53657292],\n",
       "       [ 0.83665564, -0.00885131],\n",
       "       [-0.40403765,  0.55142668]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sin(nda)           # 每个元素求正弦值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21.5"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.average(nda)       # 均值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 矩阵运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "A = np.array([[1, 2],\n",
    "              [3, 4]])\n",
    "B = np.array([[1, 1],\n",
    "              [1, 1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 3],\n",
       "       [4, 5]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A + B                  # 矩阵求和"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 3],\n",
       "       [7, 7]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.dot(B)               # 矩阵运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[3, 3],\n",
       "        [7, 7]],\n",
       "\n",
       "       [[3, 3],\n",
       "        [7, 7]]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "As = np.array([[[1, 2],\n",
    "                [3, 4]],\n",
    "               [[1, 2],\n",
    "                [3, 4]],\n",
    "              ])\n",
    "Bs = np.array([[[1, 1],\n",
    "                [1, 1]],\n",
    "               [[1, 1],\n",
    "                [1, 1]],\n",
    "               ])\n",
    "np.matmul(As, Bs)        # 批量矩阵运算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 广播\n",
    "\n",
    "- 数学中的矩阵运算要求两个矩阵的形状必须相匹配\n",
    "  - 在高维矩阵运算中可能会带来不必要的计算量和存储空间\n",
    "- 广播(Broadcast)\n",
    "  - 是 NumPy 中的一种特有的运算机制，目的就是适当放松矩阵运算中必须要求形状相匹配的条件，提升运算效率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[2, 3],\n",
       "        [4, 5]],\n",
       "\n",
       "       [[2, 3],\n",
       "        [4, 5]]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "As = np.array([[[1, 2],            # As为3维数组\n",
    "                [3, 4]],\n",
    "               [[1, 2],\n",
    "                [3, 4]],\n",
    "               ])\n",
    "B = np.array([[1, 1], [1, 1]])     # B为2维数组\n",
    "\n",
    "As + B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[3, 3],\n",
       "        [7, 7]],\n",
       "\n",
       "       [[3, 3],\n",
       "        [7, 7]]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "As.dot(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- NumPy 多维数组运算中，一旦发生形状不匹配的情况就会自动触发广播\n",
    "- 广播的逻辑本质，是在特定维度上复制数组使得其形状相匹配\n",
    "- 广播相关概念\n",
    "  - 轴(Axes)\n",
    "    - NumPy 多维数组中的一个维度称为一个轴\n",
    "  - 轴长\n",
    "    - 一个轴上数据元素的数量称为维度的轴长\n",
    "  - 后尾维度(Trailing Dimension)\n",
    "    - 高维数组的最后一个或多个连续的轴"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- As和B具有相同的后尾维度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2, 2)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "As.shape # As的形状是由其3个有序的轴的长度构成的元组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.shape #B的形状 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 广播的条件\n",
    "  - 当数组维度不同时，后尾维度的轴长(或形状)相符\n",
    "  - 当数组维度相同时，其中之一拥有至少一个轴长为 1 的维度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[2, 3],\n",
       "        [4, 5]],\n",
       "\n",
       "       [[2, 3],\n",
       "        [4, 5]]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = np.array([[[1, 1], [1, 1]]])\n",
    "As + B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[[3, 3]],\n",
       "\n",
       "        [[7, 7]]],\n",
       "\n",
       "\n",
       "       [[[3, 3]],\n",
       "\n",
       "        [[7, 7]]]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "As.dot(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 8.5.2 SciPy\n",
    "\n",
    "- SciPy 是一个常用于数学、科学、工程领域的工具包，可用于解决数值计算、积分、 优化、图像处理、常微分方程数求解、信号处理等问题\n",
    "- SciPy 依赖于 NumPy\n",
    "\n",
    "#### 特征值与特征向量求解\n",
    "\n",
    "- 矩阵$\\mathbf A$的特征值和特征向量分别是满足下式的向量$\\mathbf v$和标量$\\lambda$：\n",
    "\n",
    "$$\n",
    "\\mathbf A \\mathbf v = \\lambda \\mathbf v\n",
    "$$\n",
    "\n",
    "- 可利用`scipy.linalg`中的`eig`函数来求特征值与特征向量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2.+0.j, 11.+0.j,  2.+0.j])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from scipy import linalg\n",
    "\n",
    "A = np.array([[6, 2, 4],\n",
    "              [2, 3, 2],\n",
    "              [4, 2, 6]])\n",
    "lmds, vs = linalg.eig(A)\n",
    "lmds       # 特征值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.74535599,  0.66666667, -0.34869867],\n",
       "       [ 0.2981424 ,  0.33333333, -0.65103258],\n",
       "       [ 0.59628479,  0.66666667,  0.67421496]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vs         # 每一列是一个特征向量"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 奇异值分解\n",
    "\n",
    "- 奇异值分解是将形如$m\\times n$的矩阵$\\mathbf A$分解为如下形式：\n",
    "\n",
    "$$\n",
    "\\mathbf A = \\mathbf U\\Sigma \\mathbf V\n",
    "$$\n",
    "\n",
    "其中$\\mathbf U$和$\\mathbf V$为分别为$m\\times m$和$n\\times n$的正交矩阵\n",
    "（$\\mathbf{UU}^{\\top}=\\mathbf I$，$\\mathbf{VV}^{\\top}=\\mathbf I$），\n",
    "分别称为左奇异矩阵和右奇异矩阵；$\\Sigma$为仅主对角线元素有非零值的$m\\times n$矩阵，\n",
    "这些非零值称为奇异值\n",
    "\n",
    "- 奇异值分解在数据降维和压缩、信息推荐、数据去噪等领域有重要的应用价值\n",
    "- 可利用`scipy.linalg`中的`svd`函数来对矩阵进行奇异值分解\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import linalg\n",
    "A = np.array([[1,  5,  7,  6,  1],\n",
    "              [2,  1, 10,  4,  4],\n",
    "              [3,  6,  7,  5,  2]])\n",
    "U, Sigma, V = linalg.svd(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.55572489,  0.40548161, -0.72577856],\n",
       "       [-0.59283199, -0.80531618,  0.00401031],\n",
       "       [-0.58285511,  0.43249337,  0.68791671]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "U        # 左奇异矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([18.53581747,  5.0056557 ,  1.83490648])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Sigma   # 奇异值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.18828164, -0.37055755, -0.74981208, -0.46504304, -0.22080294],\n",
       "       [ 0.01844501,  0.76254787, -0.4369731 ,  0.27450785, -0.38971845],\n",
       "       [ 0.73354812,  0.27392013, -0.12258381, -0.48996859,  0.36301365],\n",
       "       [ 0.36052404, -0.34595041, -0.43411102,  0.6833004 ,  0.30820273],\n",
       "       [-0.5441869 ,  0.2940985 , -0.20822387, -0.0375734 ,  0.7567019 ]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V       # 右奇异矩阵"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 稀疏矩阵\n",
    "\n",
    "- 稀疏矩阵\n",
    "  - 矩阵中绝大多数元素是零或者是接近0的数字\n",
    "- 稀疏矩阵的存储方式\n",
    "  - SciPy 的sparse 模块中提供了7种类型的稀疏矩阵"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| 类型         | 结构特点                              | 优点                                     | 缺点                                    |\n",
    "| :-------- | :--------- | :-------------- | :-------------- |\n",
    "| `coo_matrix` | 采用(行, 列, 数据)三 元组形式存储数据 | 创建方便，结构转换快                     | 不支持运算和切片操作                    |\n",
    "| `dok_matrix` | 基于字典存储数据                      | 创建方便，结构转换快                     | 运算效率低，不支持切片操作              |\n",
    "| `csr_matrix` | 按行压缩存储数据                      | 运算效率高，行切片效率高                 | 列切片效率低，结构转换慢                |\n",
    "| `csc_matrix` | 按列压缩存储数据                      | 运算效率高，列切片效率高                 | 行切片效率低，结构转换慢                |\n",
    "| `bsr_matrix` | 采用分块方式存储数据                  | 运算效率高，适用于有密集子矩阵的稀疏矩阵 | 切片效率低，结构转换慢                  |\n",
    "| `lil_matrix` | 采用嵌套列表存储数据                  | 行切片效率高，结构转换快                 | 运算效率低，列切片效率低                |\n",
    "| `dia_matrix` | 按对角线存储数据                      | 运算效率高，对角性良好时存储效率高       | 对角性不好时存储效率低，不 支持切片操作 |\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- `coo_matrix`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "scipy.sparse.coo.coo_matrix"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from scipy import sparse\n",
    "row_index = [0, 1, 1, 2, 3, 4]\n",
    "col_index = [1, 2, 4, 2, 3, 2]\n",
    "data = [1, 2, 3, 4, 5, 6]\n",
    "m_coo = sparse.coo_matrix((data, (row_index, col_index)), dtype=float)\n",
    "type(m_coo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  (0, 1)\t1.0\n",
      "  (1, 2)\t2.0\n",
      "  (1, 4)\t3.0\n",
      "  (2, 2)\t4.0\n",
      "  (3, 3)\t5.0\n",
      "  (4, 2)\t6.0\n"
     ]
    }
   ],
   "source": [
    "print(m_coo)                      # 显示矩阵元素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0., 1., 0., 0., 0.],\n",
       "        [0., 0., 2., 0., 3.],\n",
       "        [0., 0., 4., 0., 0.],\n",
       "        [0., 0., 0., 5., 0.],\n",
       "        [0., 0., 6., 0., 0.]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m_coo.todense()                   # 转密度矩阵"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- `csr_matrix`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "scipy.sparse.csr.csr_matrix"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from scipy.sparse import linalg\n",
    "\n",
    "m_csr = m_coo.tocsr()             # 将coo_matrix转为csr_matrix\n",
    "type(m_csr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 1.,  0.,  0.,  0.,  0.],\n",
       "        [ 0., 13.,  8.,  0., 12.],\n",
       "        [ 0.,  8., 16.,  0., 24.],\n",
       "        [ 0.,  0.,  0., 25.,  0.],\n",
       "        [ 0., 12., 24.,  0., 36.]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m_trans = m_csr.transpose()       # 稀疏矩阵转置\n",
    "mm = m_csr.dot(m_trans)           # 稀疏矩阵矩阵相乘\n",
    "mm.todense()                      # 将稀疏矩阵转为密度矩阵"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 8.6 数据可视化*\n",
    "\n",
    "- Matplotlib是Python中著名的绘图库。它最初是对Matlab绘图命令的模仿，目前是Python绘图领域影响最为广泛的工具\n",
    "\n",
    "### 8.6.1 简单绘图\n",
    "\n",
    "- `pyplot`模块定义了大量函数用于绘制、配置或修改图像\n",
    "\n",
    "|函数| 功能|\n",
    "|:--|:--|\n",
    "|`plot`| 折线图 |\n",
    "|`scatter`| 散点图 |\n",
    "|`bar`| 柱状图 |\n",
    "|`pie`| 饼图 |\n",
    "|`hist`| 直方图 |\n",
    "|`imshow`| 热力图|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "#（a）折线图\n",
    "x = range(10)\n",
    "y = [i**2 for i in x]\n",
    "plt.plot(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#（b）散点图\n",
    "x = range(10)\n",
    "y = [i**2 for i in x]\n",
    "plt.scatter(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#（c）柱状图\n",
    "x = range(10)\n",
    "y = [i**2 for i in x]\n",
    "plt.bar(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#（d）饼图\n",
    "numbers = [0.1, 0.4, 0.3, 0.2]\n",
    "plt.pie(numbers)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#（e）直方图\n",
    "x = [1, 1, 2, 2, 2, 2, 3, 3]\n",
    "plt.hist(x)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#（f）热力图\n",
    "X = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "plt.imshow(X)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 8.6.2 图像的配置与修饰\n",
    "\n",
    "- Matplotlib图像的主要组成部分\n",
    "  - 图像：是一个`Figure`对象。常用的属性包括图像的大小(`figsize`)、分辨率(`dpi`)等，可包含一个或多个坐标轴\n",
    "  - 坐标轴：图像的子图，是一个`AxesSubplot`对象。常用属性有标题(`title`)等，每个坐标轴由 x 轴(`xaxis`)和 y 轴(`yaxis`)组成，每个轴都可以配置自己的标识 (`xlabel`或`ylabel`)、刻度、刻度范围、刻度标识等\n",
    "  - 绘图：具体的图形对象，可以是折线图、散点图等。属性有线形、宽度、颜色、修饰符(marker)及其形状和颜色等\n",
    "  - 填充：在折线图与坐标轴之间(坐标轴的`fill`方法)或者不同的折线之间 (坐标轴的`fill_between`方法)填充颜色\n",
    "  - 图例：根据绘图的线形、颜色、修饰符等自动生成\n",
    "  - 标注：使用坐标轴的annotate方法或text方法添加文本或箭头等形状，文本中支持 Latex 符号和公式"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"./figures/fig8-3.png\" width=\"70%\"/>\n",
    "<center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.ticker import MultipleLocator\n",
    "\n",
    "font = {'family': 'simhei', 'size':12}  # 中文字体和字号\n",
    "# 图像大小和分辨率\n",
    "plt.figure(figsize=[8, 6], dpi=100)\n",
    "\n",
    "# 折线图\n",
    "x = np.arange(-10, 10.1, 0.1)\n",
    "y1 = x ** 2\n",
    "y2 = np.array([64] * len(x))\n",
    "plt.plot(x, y1, label='$y=x^2$', marker='s', markevery=20)\n",
    "plt.plot(x, y2, label='$y=64$', marker='o', markevery=20)\n",
    "\n",
    "# 区域填充\n",
    "x_fill = np.arange(-8, 8, 0.1)\n",
    "y1_fill = x_fill ** 2\n",
    "y2_fill = np.array([64]*len(x_fill))\n",
    "plt.fill_between(x_fill, y1_fill, y2_fill, alpha=.2)\n",
    "\n",
    "# 坐标轴配置\n",
    "plt.xlim(-11, 11)      # x轴刻度区间\n",
    "plt.ylim(-5, 105)      # y轴刻度区间\n",
    "ax = plt.gca()         # 获取坐标轴对象\n",
    "# ax.set_xticks(range(-10, 11, 5))   # 设置x轴刻度\n",
    "# ax.set_yticks(range(-0, 101, 10))  # 设置y轴刻度\n",
    "ax.xaxis.set_major_locator(MultipleLocator(5))  # x轴主刻度\n",
    "ax.xaxis.set_minor_locator(MultipleLocator(1))  # x轴副刻度\n",
    "ax.yaxis.set_major_locator(MultipleLocator(10)) # y轴主刻度\n",
    "ax.yaxis.set_minor_locator(MultipleLocator(5))  # y轴副刻度\n",
    "\n",
    "plt.annotate('$y=x^2$', xy=(-9, 81), xytext=(-7, 90),  # 标注\n",
    "            arrowprops={'arrowstyle': \"->\"})\n",
    "plt.xlabel('x轴标识（xlabel）', fontdict=font)    # x轴标识\n",
    "plt.ylabel('y轴标识（ylabel）', fontdict=font)    # y轴标识\n",
    "plt.title(\"标题（title）\", fontdict={'family': 'simhei'})  # 图像标题\n",
    "plt.legend(loc='upper right')                   # 图例\n",
    "plt.show()                                      # 显示图像"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 中美新冠病毒确诊数量对比"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "matplotlib.rc('font', family='simsun')          # 设置字体\n",
    "china = [11791, 79824, 81554, 82874, 83017, 83534, 84337,\n",
    "         85058, 85414, 85997, 86542, 87071]\n",
    "usa = [11, 66, 140640, 1003974, 1734040, 2537636, 4388566,\n",
    "       5899504, 7077015, 8852730, 13082877, 19346790]\n",
    "mothons = ['1月', '2月', '3月', '4月', '5月', '6月',\n",
    "           '7月', '8月', '9月', '10月', '11月', '12月']\n",
    "plt.plot(china, label='中国', marker='o')\n",
    "plt.plot(usa, label='美国', marker='s')\n",
    "plt.legend()\n",
    "plt.xticks(range(0, 12), mothons, rotation=45)  # 设置x轴坐标标签\n",
    "plt.yscale('log')                               # 设置y轴为对数坐标\n",
    "plt.title('中美新冠病毒确诊数量对比', fontdict={'size': 16})\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 8.6.3 多子图图像的绘制\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.subplot(2, 2, 1)  # 2行2列第 1 幅子图像\n",
    "plt.text(0.5, 0.5, 'subplot(2,2,1)', ha='center', va='center', size=15)\n",
    "plt.subplot(2, 2, 2)  # 2行2列第 2 幅子图像\n",
    "plt.text(0.5, 0.5, 'subplot(2,2,2)', ha='center', va='center', size=15)\n",
    "plt.subplot(2, 2, 3)  # 2行2列第 3 幅子图像\n",
    "plt.text(0.5, 0.5, 'subplot(2,2,3)', ha='center', va='center', size=15)\n",
    "plt.subplot(2, 2, 4)  # 2行2列第 4 幅子图像\n",
    "plt.text(0.5, 0.5, 'subplot(2,2,4)', ha='center', va='center', size=15)\n",
    "plt.subplots_adjust(left=0.08, bottom=0.08, right=0.96, top=0.96, \n",
    "                    wspace=0.3, hspace=0.3)  # 调整图像的边距和间距\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 8.6.4 三维图像的绘制\n",
    "\n",
    "- Matplotlib的`mpl_toolkits`辅助模块中提供了各种三维图像的绘制功能\n",
    "- 函数$Z=\\sin(\\sqrt{X^2+Y^2})$的三维图像"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib as mpl\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "mpl.rcParams['axes.unicode_minus']=False  # 使负号正常显示\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = Axes3D(fig)\n",
    "\n",
    "X = np.arange(-6, 6, 0.1)\n",
    "Y = np.arange(-6, 6, 0.1)\n",
    "X, Y = np.meshgrid(X, Y)\n",
    "Z = np.sin(np.sqrt(X**2 + Y**2))\n",
    "\n",
    "ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='coolwarm')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 8.7 Pandas基础*\n",
    "\n",
    "- Pandas是Python数据分析与处理领域非常知名的工具之一，常用于结构化数据分析任务，例如数据分析、数据挖掘和数据清洗等\n",
    "- 从功能上来说可以粗略地认为它是电子表格和结构化查询语言（SQL）相结合的Python实现\n",
    "\n",
    "### 8.7.1 数据结构\n",
    "\n",
    "#### 系列（`Series`）\n",
    "\n",
    "- 系列本质上是带有索引的一维数组元素可以是整数、浮点数、字符串，以及其他的 Python 对象\n",
    "- 可以基于列表、字典或者 Numpy 数组来创建一个系列"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    1\n",
       "1    4\n",
       "2    2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "lst = [1, 4, 2]\n",
    "s1 = pd.Series(lst)                        # 由列表创建系列\n",
    "s1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    1\n",
       "1    4\n",
       "2    2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s2 = pd.Series(np.array(lst))              # 由Numpy数组创建系列\n",
    "s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1\n",
       "b    4\n",
       "c    2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s3 = pd.Series(lst, index=['a', 'b', 'c']) # 系列的标签索引\n",
    "s3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.0\n",
       "b    2.0\n",
       "c    3.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dic = {'a': 1, 'b': 2, 'c': 3}\n",
    "s4 = pd.Series(dic, dtype=float)           # 由字典创建系列\n",
    "s4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 数据框\n",
    "\n",
    "- 普通的数据框从逻辑上来说是一种二维表格\n",
    "- 可以基于二维列表或二 维 Numpy 数组创建数据框，也可以基于系列来创建数据框"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0  1\n",
       "a  1  8\n",
       "b  4  5\n",
       "c  2  7"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = [[1, 8],[4, 5],[2, 7]]\n",
    "df1 = pd.DataFrame(lst, index=['a', 'b', 'c'])  # 由列表创建数据框\n",
    "df1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>s1</th>\n",
       "      <th>s2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   s1  s2\n",
       "0   1   8\n",
       "1   4   5\n",
       "2   2   7"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2 = pd.DataFrame(np.array(lst),               # 由Numpy数组创建数据框，\n",
    "                   columns=['s1', 's2'])        # 并指定列名\n",
    "df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>s1</th>\n",
       "      <th>s2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   s1  s2\n",
       "0   1   8\n",
       "1   4   5\n",
       "2   2   7"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = pd.Series([1, 4, 2])\n",
    "s2 = pd.Series([8, 5, 7])\n",
    "df3 = pd.DataFrame({'s1': s1, 's2': s2})  # 由系列创建数据框\n",
    "df3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>s1</th>\n",
       "      <th>s2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   s1  s2\n",
       "0   1   8\n",
       "1   4   5\n",
       "2   2   7\n",
       "3   0   0"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df3 = df3.append({'s1': 0, 's2':0}, ignore_index=True)  # 添加行\n",
    "df3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>s1</th>\n",
       "      <th>s2</th>\n",
       "      <th>new</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   s1  s2  new\n",
       "0   1   8    9\n",
       "1   4   5    9\n",
       "2   2   7    9\n",
       "3   0   0    0"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df3['new'] = df3.s1 + df3.s2              # 添加列\n",
    "df3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 数据框的读入和写出\n",
    "  - Pandas支持多种格式数据的读入和写出，常用的格式包括Excel、CSV、JSON、SQL、HDF、STATA、SAS、SPSS等。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>s1</th>\n",
       "      <th>s2</th>\n",
       "      <th>new</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   s1  s2  new\n",
       "0   1   8    9\n",
       "1   4   5    9\n",
       "2   2   7    9\n",
       "3   0   0    0"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df3.to_csv('test.csv', index=False)  # 保存为CSV格式（不保存索引）\n",
    "df4 = pd.read_csv('test.csv')        # 读入CSV格式创建数据框\n",
    "df4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 8.7.2 数据访问\n",
    "\n",
    "#### 索引访问"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s4[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.0\n",
       "b    2.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s4[0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s4['a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.0\n",
       "c    3.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s4[[0, 2]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.0\n",
       "c    3.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s4[['a', 'c']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 数据框的索引访问常用到三个属性\n",
    "  - `loc`: 使用标签索引来访问一行或多行\n",
    "  - `iloc`: 使用整数索引来访问一行或多行\n",
    "  - `iat`: 通过指定行和列来访问数据框元素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>c1</th>\n",
       "      <th>c2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   c1  c2\n",
       "a   1   8\n",
       "b   4   5\n",
       "c   2   7"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = [[1, 8],[4, 5],[2, 7]]\n",
    "df = pd.DataFrame(lst, index=['a', 'b', 'c'], columns=['c1', 'c2'])\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1\n",
       "b    4\n",
       "c    2\n",
       "Name: c1, dtype: int64"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.c1                    # 访问c1列，等同于df['c1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>c1</th>\n",
       "      <th>c2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   c1  c2\n",
       "a   1   8\n",
       "b   4   5"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.loc[['a', 'b']]       # 访问a和b两行"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1\n",
       "b    4\n",
       "Name: c1, dtype: int64"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.loc[['a', 'b'], 'c1'] # 访问a和b两行的c1列"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>c1</th>\n",
       "      <th>c2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   c1  c2\n",
       "a   1   8\n",
       "c   2   7"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.iloc[0:3:2]           # 行切片，等于与df[0:3:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1\n",
       "b    4\n",
       "Name: c1, dtype: int64"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.iloc[0:2, 0]          # 访问0到1行第0列"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.iat[0, 1]             # 访问位于第0行第1列的元素"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 条件选择\n",
    "\n",
    "- 根据指定的条件对系列或数据框的值进行过滤"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [[1, 8],[4, 5],[2, 7]]\n",
    "df = pd.DataFrame(lst, index=['a', 'b', 'c'], columns=['c1', 'c2'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>c1</th>\n",
       "      <th>c2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   c1  c2\n",
       "b   4   5\n",
       "c   2   7"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[df.c1>1]                 # c1列大于1的行"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>c1</th>\n",
       "      <th>c2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   c1  c2\n",
       "c   2   7"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[(df.c1>1) & (df.c2>5)]   # c1列大于1且c2列大于5的行"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>c1</th>\n",
       "      <th>c2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   c1  c2\n",
       "a   1   8\n",
       "b   4   5"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[(df.c1>2) | (df.c2>7)]   # c1列大于2或c2列大于7的行"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 迭代\n",
    "\n",
    "- 数据框可以生成多种类型的迭代器，能够对行进行不同形式的迭代遍历"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "lst = [[1, 8],[4, 5],[2, 7]]\n",
    "df = pd.DataFrame(lst, index=['a', 'b', 'c'], columns=['c1', 'c2'])\n",
    "for v in df.c1:               # 遍历系列\n",
    "    print(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a 1 8\n",
      "b 4 5\n",
      "c 2 7\n"
     ]
    }
   ],
   "source": [
    "for i, r in df.iterrows():    # 遍历数据框的行\n",
    "    print(i, r[0], r[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pandas(Index='a', c1=1, c2=8)\n",
      "Pandas(Index='b', c1=4, c2=5)\n",
      "Pandas(Index='c', c1=2, c2=7)\n"
     ]
    }
   ],
   "source": [
    "for r in df.itertuples():     # 遍历数所框的行\n",
    "    print(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 统计分析\n",
    "\n",
    "- 系列数据常用统计方法\n",
    "\n",
    "|函数 |功能|\n",
    "|:--|:--|\n",
    "|`count`| 数据量 |\n",
    "|`sum`|  求和 |\n",
    "|`mean`|  均值 |\n",
    "|`median`|  中位数 |\n",
    "|`std`|  准偏差 |\n",
    "|`min`|  最小值 |\n",
    "|`max`|  最大值 |\n",
    "|`value_counts`|  频次统计|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 数据框的描述信息"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>c1</th>\n",
       "      <th>c2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>3.000000</td>\n",
       "      <td>3.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>2.333333</td>\n",
       "      <td>6.666667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>1.527525</td>\n",
       "      <td>1.527525</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>5.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>1.500000</td>\n",
       "      <td>6.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>2.000000</td>\n",
       "      <td>7.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>3.000000</td>\n",
       "      <td>7.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>4.000000</td>\n",
       "      <td>8.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             c1        c2\n",
       "count  3.000000  3.000000\n",
       "mean   2.333333  6.666667\n",
       "std    1.527525  1.527525\n",
       "min    1.000000  5.000000\n",
       "25%    1.500000  6.000000\n",
       "50%    2.000000  7.000000\n",
       "75%    3.000000  7.500000\n",
       "max    4.000000  8.000000"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = [[1, 8],[4, 5],[2, 7]]\n",
    "df = pd.DataFrame(lst, index=['a', 'b', 'c'], columns=['c1', 'c2'])\n",
    "df.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 协方差和相关系数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.01931279550960339"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.random.randn(100, 2)\n",
    "df = pd.DataFrame(data, columns=['c1', 'c2'])\n",
    "df.c1.cov(df.c2)            # c1列与c2列的协方差 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>c1</th>\n",
       "      <th>c2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>c1</th>\n",
       "      <td>0.853200</td>\n",
       "      <td>-0.019313</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c2</th>\n",
       "      <td>-0.019313</td>\n",
       "      <td>0.715135</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          c1        c2\n",
       "c1  0.853200 -0.019313\n",
       "c2 -0.019313  0.715135"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.cov()                    # df中各列的协议差矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.024724395919958092"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.c1.corr(df.c2)           # c1列与c2列的相关系数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>c1</th>\n",
       "      <th>c2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>c1</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>-0.024724</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c2</th>\n",
       "      <td>-0.024724</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          c1        c2\n",
       "c1  1.000000 -0.024724\n",
       "c2 -0.024724  1.000000"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.corr(method='pearson')   # df中各列的相关矩阵"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 8.8 Scikit-learn基础*\n",
    "\n",
    "### 8.8.1 Scikit-learn简介\n",
    "\n",
    "- Scikit-learn是一种通用的机器学习工具包，它依赖 NumPy、SciPy 和 Matplotlib 以实现高效的数值过算、优化和可视化\n",
    "- Scikit-learn对整个机器学习流程提供了完整的支持，例如数据集读取、数据处理与 转换、模型及学习方法、模型的评价与选择等\n",
    "- Scikit-learn的核心功能\n",
    "\n",
    "| 功能           | 描述                                                         |\n",
    "| :-------------- | :------------------------------------------ |\n",
    "| 有监督学习模型 | 分类模型、回归模型、集成学习模型、有监督神经网络模型、半监督学习模型，以及特征选择工具 |\n",
    "| 无监督学习模型 | 聚类模型、双向聚类模型、包括高斯混合模型、流形学习、矩阵分解、变 分估计、异常检测、密度估计、有监督神经网络模型 |\n",
    "| 模型选择与评价 | 交叉验证、调参工具、性能评价指标、模型保存、偏差/方差分析    |\n",
    "| 模型解释       | 部分依赖图(PDP)、排列特征重要性(Permutation feature importance) |\n",
    "| 可视化         | 数据可视化、学习过程可视化、模型评价/选择可视化等            |\n",
    "| 数据转换工具   | 特征提取、数据预处理、缺失值处理、数据降维、标签处理、核方法 |\n",
    "| 数据集工具     | 内置数据集、数据集生成工具、数据集加载工具                   |\n",
    "| 高性能计算工具 | 大数据集处理、并行计算、资源管理与配置                       |\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Scikit-learn 将大多数机器学习功能封装为类并基于相同或相似的接口实现，主要可分为如下三种\n",
    "  -  Estimator:估计器，各常机器学习模型都被封装为估计器。绝大多数估计器都有如下三个方法:\n",
    "     - fit(x, y):根据数据x及标签y对模型进行训练\n",
    "     - score(x, y):根据数据x及标签y对训练好的模型进行评价\n",
    "     - predict(x):利用训练好的模型预测数据x的标签\n",
    "  - Transformer:转换器，对数据进行转换操作，如标准化、降维、特征选择等。大多数转换器都有如下三个方法:\n",
    "     - fit(x, y):根据数据x和标签y确定数据转换方式\n",
    "     - transform(x):根据确定的转换方式，对数据x进行转换\n",
    "     - fit_transform(x, y):确定数据转换方式，并且对数据进行转换\n",
    "  - Pipline\n",
    "   - 将数据处理、转换到模型学习等多个步骤组装为一个完整的过程以便于 模型的训练和使用，通常会包含多个转换器和一个估计器。Pipline对象也有fit、 score、predict、fit_transform等方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 8.8.2 分类问题\n",
    "\n",
    "- 分类问题\n",
    "  - 给定一组类别已知的样本数据集（有监督数据），确定一个分类函数用于对类别未知的数据的所属类别进行预测\n",
    "- k 最近邻算法\n",
    "  - step1：确定 k 值以及样本距离的定义方式\n",
    "  - step2：对于数据集中的样本s，计算它与其他样本数据的距离\n",
    "  - step3：确定距离最近的k个样本以及它们所属的类别c\n",
    "  - step4：将s的类别标记为c\n",
    "- 鸢尾花数据集（Iris）\n",
    "  - 每个样本对应着一朵鸢尾花样本，记录着花萼长度、花萼宽度、花瓣长度、花瓣宽度四个特征\n",
    "  - 数据集中共包含三个类别（iris-setosa、iris-versicolour和iris-virginica）的鸢尾花样本\n",
    "  - 每个类别共有50个样本数据"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 鸢尾花分类的 k 最近邻模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "测试集正确率： 0.9666666666666667\n",
      "预测样本： [5.4 3.7 1.5 0.2]\n",
      "预测类别： setosa\n",
      "真实类别： setosa\n"
     ]
    }
   ],
   "source": [
    "from sklearn import neighbors, datasets\n",
    "from sklearn.utils import shuffle\n",
    "\n",
    "iris = datasets.load_iris()                          # 加载数据集\n",
    "\n",
    "X, y = shuffle(iris.data, iris.target)               # 随机打乱数据\n",
    "X_train, X_test = X[:120], X[120:]                   # 训练集与测试集特征\n",
    "y_train, y_test = y[:120], y[120:]                   # 训练集与测试集标签\n",
    "\n",
    "knn = neighbors.KNeighborsClassifier(n_neighbors=10, # K最近邻估计器\n",
    "                                     metric='minkowski', p=2)\n",
    "knn.fit(X_train, y_train)                            # 训练\n",
    "\n",
    "accuracy = knn.score(X_test, y_test)                 # 模型评价\n",
    "print(\"测试集正确率：\", accuracy)\n",
    "\n",
    "d_id = 10\n",
    "data_x = iris.data[d_id]\n",
    "data_y = iris.target[d_id]\n",
    "result = knn.predict([data_x])                       # 预测\n",
    "\n",
    "print('预测样本：', data_x)\n",
    "print('预测类别：', iris.target_names[result[0]])\n",
    "print('真实类别：', iris.target_names[data_y])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 8.8.3 聚类问题\n",
    "\n",
    "- 聚类问题\n",
    "  - 给定一组样本数据根据相似度，将 它们划分入不同的类别，使得类内数据之间的距离尽可能小，类与类之间的距离尽可能 大\n",
    "- $k$均值模型\n",
    "  - 第一，计算数据与聚类中心之间的距离，并将其划分入距离最近的中心表示的类别之中\n",
    "  - 第二，根据新的数据类别划分结果，更新类别中心的位置\n",
    "  - 重复这两个步骤，直到达到最大迭代次数或者类别中心的位置不再发生变化"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- $k$均值模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from sklearn.cluster import KMeans\n",
    "from sklearn.datasets import make_blobs\n",
    "\n",
    "font = {'family': 'simsun', 'size': 12}\n",
    "plt.figure(figsize=[10, 5])\n",
    "\n",
    "centers = [[0, 1], [-1, -1], [1, -1]]\n",
    "X, labels_true = make_blobs(n_samples=300,              # 生成数据集\n",
    "                            centers=centers, cluster_std=0.3)\n",
    "\n",
    "# 画出原始数据\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.scatter(X[:, 0], X[:, 1])\n",
    "plt.xlabel('(a) 原始数据', fontdict=font)\n",
    "\n",
    "k_means = KMeans(n_clusters=3)                          # K均值估计器\n",
    "k_means.fit(X)                                          # 聚类\n",
    "\n",
    "# 画出聚类结果\n",
    "plt.subplot(1, 2, 2)\n",
    "marker_list = ['o', 's', '^']\n",
    "color_list = ['r', 'b', 'g']\n",
    "for i in range(3):\n",
    "    c_data = X[k_means.labels_ == i]  # 获取一个类别的数据\n",
    "    plt.scatter(c_data[:, 0], c_data[:, 1],             # 画出一个类别\n",
    "                c=color_list[i], marker=marker_list[i], alpha=0.6)\n",
    "\n",
    "plt.xlabel('(b) 聚类结果', fontdict=font)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "author": "liuchen",
  "celltoolbar": "幻灯片",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.1"
  },
  "rise": {
   "enable_chalkboard": true,
   "footer": "",
   "progress": true,
   "scroll": true,
   "slideNumber": true
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "221.63601684570312px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  },
  "url": "https://github.com/hitlic/python_book"
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
